<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Java基础语法教程</title>
    <style>
        body {
            font-family: 'Inter', sans-serif;
            background-color: #f8f9fa; /* 浅灰背景 */
            color: #212529; /* 深色文字 */
            line-height: 1.6;
            margin: 0;
            padding: 0;
            display: flex;
            justify-content: center;
        }
        .container {
            max-width: 800px;
            margin: 40px;
            padding: 30px;
            background-color: #ffffff; /* 白色内容区 */
            border-radius: 8px;
            box-shadow: 0 0 15px rgba(0,0,0,0.1);
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Merriweather', serif;
            color: #343a40;
            margin-top: 1.5em;
            margin-bottom: 0.8em;
        }
        h1 { font-size: 2.5em; }
        h2 { font-size: 2em; }
        h3 { font-size: 1.75em; }
        p {
            margin-bottom: 1em;
        }
        a {
            color: #3b82f6; /* 强调色：明亮蓝色 */
            text-decoration: none;
        }
        a:hover {
            text-decoration: underline;
        }
        pre {
            background-color: #e9ecef;
            padding: 15px;
            border-radius: 5px;
            overflow-x: auto;
            font-family: 'IBM Plex Mono', monospace;
            font-size: 0.9em;
        }
        code {
            font-family: 'IBM Plex Mono', monospace;
            background-color: #e9ecef;
            padding: 0.2em 0.4em;
            border-radius: 3px;
        }
        pre code {
            padding: 0;
            background-color: transparent;
            border-radius: 0;
        }
        ul, ol {
            padding-left: 20px;
            margin-bottom: 1em;
        }
        li {
            margin-bottom: 0.5em;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin-bottom: 1.5em;
        }
        th, td {
            border: 1px solid #dee2e6;
            padding: 8px 12px;
            text-align: left;
        }
        th {
            background-color: #f1f3f5;
            font-weight: bold;
        }
        strong, b {
            font-weight: bold;
        }
        em, i {
            font-style: italic;
        }
        /* 微妙网格背景图案 - 可选 */
        /* body::before {
            content: '';
            position: fixed;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            background-image: linear-gradient(rgba(0,0,0,0.03) 1px, transparent 1px), linear-gradient(90deg, rgba(0,0,0,0.03) 1px, transparent 1px);
            background-size: 20px 20px;
            z-index: -1;
            opacity: 0.5;
        } */
    </style>
    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;700&family=Merriweather:wght@400;700&family=IBM+Plex+Mono&display=swap" rel="stylesheet">
    <link href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism-solarizedlight.min.css" rel="stylesheet" />
</head>
<body>
    <div class="container">
<h1>Java基础语法教程</h1>

<h2>1. Java简介</h2>

<p>Java是一种广泛使用的高级编程语言，由Sun Microsystems（现为Oracle公司）于1995年发布。它具有以下特点：</p>

<ul>
<li><strong>简单性</strong>：Java语法相对C++来说更简单，易于学习。</li>
<li><strong>面向对象</strong>：Java是一种纯粹的面向对象编程语言。</li>
<li><strong>平台无关性</strong>：Java代码编译成字节码（.class文件），可以在任何安装了Java虚拟机（JVM）的平台上运行，实现“一次编写，到处运行”。</li>
<li><strong>健壮性</strong>：Java具有强大的内存管理和异常处理机制。</li>
<li><strong>安全性</strong>：Java提供了安全机制，防止恶意代码的执行。</li>
<li><strong>多线程</strong>：Java内置对多线程的支持，可以方便地开发并发程序。</li>
<li><strong>丰富的API</strong>：Java提供了大量预定义的类和方法，方便开发。</li>
</ul>

<h2>2. 环境搭建</h2>

<p>要开始Java编程，需要安装Java Development Kit (JDK)。
如果只是单纯的运行Java程序，可以使用 Java Runtime Environment (JRE)。</p>

<h2>3. HelloWorld</h2>

<p>让我们编写第一个Java程序。</p>

<ol>
<li>创建一个文本文件，命名为 <code>HelloWorld.java</code> (注意大小写和扩展名)。</li>
<li>用文本编辑器（如Notepad++、VS Code等）打开该文件，输入以下代码：</li>
</ol>

<pre><code class="language-java">public class HelloWorld {
    public static void main(String[] args) {
        // 这是我们的第一个Java程序
        System.out.println("Hello, World!");
    }
}
</code></pre>

<p><strong>代码解释：</strong></p>

<ul>
<li><code>public class HelloWorld</code>：定义一个公共类，类名为 <code>HelloWorld</code>。文件名必须与公共类名完全一致。</li>
<li><code>public static void main(String[] args)</code>：这是Java程序的入口点（主方法）。程序从这里开始执行。
<ul>
<li><code>public</code>：访问修饰符，表示该方法可以被任何地方访问。</li>
<li><code>static</code>：关键字，表示该方法属于类本身，而不是类的某个实例。</li>
<li><code>void</code>：表示该方法不返回任何值。</li>
<li><code>main</code>：方法名，固定写法。</li>
<li><code>String[] args</code>：方法参数，是一个字符串数组，用于接收命令行参数。</li>
</ul>
</li>
<li><code>// 这是我们的第一个Java程序</code>：这是单行注释，用于解释代码，不会被编译。</li>
<li><code>System.out.println(&quot;Hello, World!&quot;);</code>：这行代码会在控制台输出文本 &quot;Hello, World!&quot;。
<ul>
<li><code>System.out</code>：标准的输出流对象。</li>
<li><code>println()</code>：一个方法，用于打印字符串并换行。</li>
</ul>
</li>
</ul>

<h3>3.1 编译和运行</h3>

<ol>
<li>打开命令提示符或PowerShell，导航到 <code>HelloWorld.java</code> 文件所在的目录。</li>
<li><strong>编译</strong>：输入以下命令将Java源代码编译成字节码文件 (<code>.class</code>)：</li>
</ol>

<pre><code class="language-bash">javac HelloWorld.java
</code></pre>
<p>如果编译成功，会在当前目录下生成一个 <code>HelloWorld.class</code> 文件。</p>

<ol start="3">
<li><strong>运行</strong>：输入以下命令运行编译后的程序：</li>
</ol>

<pre><code class="language-bash">java HelloWorld
</code></pre>
<p>注意：运行的是类名，而不是文件名，并且不需要 <code>.class</code> 扩展名。</p>

<p>您应该会在控制台看到输出：</p>

<pre><code>Hello, World!
</code></pre>

<h2>4. 变量、数据类型、运算符、输入输出</h2>

<h3>4.1 变量 (Variables)</h3>

<p>变量是用来存储数据的容器。在Java中，使用变量前必须先声明它，并指定其数据类型。</p>

<p><strong>声明变量的语法：</strong></p>

<pre><code class="language-java">dataType variableName;
</code></pre>

<p><strong>声明并初始化变量：</strong></p>

<pre><code class="language-java">dataType variableName = value;
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">int age; // 声明一个整型变量age
age = 30; // 给变量age赋值

String name = "Alice"; // 声明一个字符串变量name并初始化
double salary = 5000.50; // 声明一个双精度浮点型变量salary并初始化
boolean isActive = true; // 声明一个布尔型变量isActive并初始化

System.out.println("姓名: " + name);
System.out.println("年龄: " + age);
System.out.println("薪水: " + salary);
System.out.println("激活状态: " + isActive);
</code></pre>

<p><strong>变量命名规则：</strong></p>

<ul>
<li>可以包含字母、数字、下划线 <code>_</code> 和美元符号 <code>$</code>。</li>
<li>必须以字母、下划线 <code>_</code> 或美元符号 <code>$</code> 开头，不能以数字开头。</li>
<li>区分大小写（<code>age</code> 和 <code>Age</code> 是不同的变量）。</li>
<li>不能使用Java的关键字（如 <code>int</code>, <code>class</code>, <code>public</code> 等）。</li>
<li>建议使用驼峰命名法（camelCase），例如 <code>firstName</code>, <code>totalAmount</code>。</li>
</ul>

<h3>4.2 数据类型 (Data Types)</h3>

<p>Java中的数据类型分为两大类：基本数据类型和引用数据类型。</p>

<h4>4.2.1 基本数据类型 (Primitive Data Types)</h4>

<table>
<thead>
<tr>
<th>类型</th>
<th>大小 (位)</th>
<th>描述</th>
<th>默认值</th>
<th>示例</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>byte</code></td>
<td>8</td>
<td>字节型整数</td>
<td>0</td>
<td><code>byte b = 10;</code></td>
</tr>
<tr>
<td><code>short</code></td>
<td>16</td>
<td>短整型</td>
<td>0</td>
<td><code>short s = 100;</code></td>
</tr>
<tr>
<td><code>int</code></td>
<td>32</td>
<td>整型</td>
<td>0</td>
<td><code>int i = 1000;</code></td>
</tr>
<tr>
<td><code>long</code></td>
<td>64</td>
<td>长整型</td>
<td>0L</td>
<td><code>long l = 100000L;</code> (注意L后缀)</td>
</tr>
<tr>
<td><code>float</code></td>
<td>32</td>
<td>单精度浮点型</td>
<td>0.0f</td>
<td><code>float f = 3.14f;</code> (注意f后缀)</td>
</tr>
<tr>
<td><code>double</code></td>
<td>64</td>
<td>双精度浮点型</td>
<td>0.0d</td>
<td><code>double d = 3.14159;</code></td>
</tr>
<tr>
<td><code>char</code></td>
<td>16</td>
<td>字符型</td>
<td>'\u0000'</td>
<td><code>char c = 'A';</code> (单引号)</td>
</tr>
<tr>
<td><code>boolean</code></td>
<td>1 (逻辑上)</td>
<td>布尔型</td>
<td>false</td>
<td><code>boolean flag = true;</code></td>
</tr>
</tbody>
</table>

<h4>4.2.2 引用数据类型 (Reference Data Types)</h4>

<p>引用数据类型指向内存中的对象。常见的引用数据类型包括：</p>

<ul>
<li><strong>类 (Class)</strong>：如 <code>String</code>, <code>Scanner</code>, 自定义的类等。</li>
<li><strong>接口 (Interface)</strong></li>
<li><strong>数组 (Array)</strong></li>
</ul>

<pre><code class="language-java">String message = "Hello"; // String是一个类
int[] numbers = new int[5]; // numbers是一个整型数组
</code></pre>

<h3>4.3 运算符 (Operators)</h3>

<p>运算符用于对变量和值执行操作。</p>

<h4>4.3.1 算术运算符</h4>

<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>示例 (<code>a=10, b=3</code>)</th>
<th>结果</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>+</code></td>
<td>加法</td>
<td><code>a + b</code></td>
<td>13</td>
</tr>
<tr>
<td><code>-</code></td>
<td>减法</td>
<td><code>a - b</code></td>
<td>7</td>
</tr>
<tr>
<td><code>*</code></td>
<td>乘法</td>
<td><code>a * b</code></td>
<td>30</td>
</tr>
<tr>
<td><code>/</code></td>
<td>除法</td>
<td><code>a / b</code></td>
<td>3 (整数除法，结果取整)</td>
</tr>
<tr>
<td><code>%</code></td>
<td>取模 (求余数)</td>
<td><code>a % b</code></td>
<td>1</td>
</tr>
<tr>
<td><code>++</code></td>
<td>自增</td>
<td><code>a++</code> (后增) 或 <code>++a</code> (前增)</td>
<td>a变为11</td>
</tr>
<tr>
<td><code>--</code></td>
<td>自减</td>
<td><code>a--</code> (后减) 或 <code>--a</code> (前减)</td>
<td>a变为9</td>
</tr>
</tbody>
</table>

<p><strong>注意整数除法：</strong> <code>10 / 3</code> 结果是 <code>3</code>。如果希望得到浮点数结果，至少有一个操作数需要是浮点型：<code>10.0 / 3</code> 或 <code>(double)10 / 3</code>。</p>

<h4>4.3.2 关系运算符 (比较运算符)</h4>

<p>用于比较两个值，结果为布尔值 (<code>true</code> 或 <code>false</code>)。</p>

<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>示例 (<code>a=10, b=5</code>)</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>==</code></td>
<td>等于</td>
<td><code>a == b</code> (false)</td>
</tr>
<tr>
<td><code>!=</code></td>
<td>不等于</td>
<td><code>a != b</code> (true)</td>
</tr>
<tr>
<td><code>&gt;</code></td>
<td>大于</td>
<td><code>a &gt; b</code> (true)</td>
</tr>
<tr>
<td><code>&lt;</code></td>
<td>小于</td>
<td><code>a &lt; b</code> (false)</td>
</tr>
<tr>
<td><code>&gt;=</code></td>
<td>大于等于</td>
<td><code>a &gt;= b</code> (true)</td>
</tr>
<tr>
<td><code>&lt;=</code></td>
<td>小于等于</td>
<td><code>a &lt;= b</code> (false)</td>
</tr>
</tbody>
</table>

<h4>4.3.3 逻辑运算符</h4>

<p>用于组合多个布尔表达式。</p>

<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>示例 (<code>x=true, y=false</code>)</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>&amp;&amp;</code></td>
<td>逻辑与 (AND)</td>
<td><code>x &amp;&amp; y</code> (false)</td>
</tr>
<tr>
<td><code>||</code></td>
<td>逻辑或 (OR)</td>
<td><code>x || y</code> (true)</td>
</tr>
<tr>
<td><code>!</code></td>
<td>逻辑非 (NOT)</td>
<td><code>!x</code> (false)</td>
</tr>
</tbody>
</table>

<p><strong>短路特性：</strong></p>
<ul>
<li><code>&amp;&amp;</code>：如果第一个表达式为 <code>false</code>，则不再计算第二个表达式。</li>
<li><code>||</code>：如果第一个表达式为 <code>true</code>，则不再计算第二个表达式。</li>
</ul>

<h4>4.3.4 赋值运算符</h4>

<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>示例 (<code>a=10</code>)</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>=</code></td>
<td>简单赋值</td>
<td><code>int x = a;</code> (x为10)</td>
</tr>
<tr>
<td><code>+=</code></td>
<td>加后赋值</td>
<td><code>a += 5;</code> (等价于 <code>a = a + 5;</code> a为15)</td>
</tr>
<tr>
<td><code>-=</code></td>
<td>减后赋值</td>
<td><code>a -= 3;</code> (等价于 <code>a = a - 3;</code> a为7)</td>
</tr>
<tr>
<td><code>*=</code></td>
<td>乘后赋值</td>
<td><code>a *= 2;</code> (等价于 <code>a = a * 2;</code> a为20)</td>
</tr>
<tr>
<td><code>/=</code></td>
<td>除后赋值</td>
<td><code>a /= 4;</code> (等价于 <code>a = a / 4;</code> a为2)</td>
</tr>
<tr>
<td><code>%=</code></td>
<td>取模后赋值</td>
<td><code>a %= 3;</code> (等价于 <code>a = a % 3;</code> a为1)</td>
</tr>
</tbody>
</table>

<h4>4.3.5 三元运算符 (条件运算符)</h4>

<p>语法：<code>condition ? expressionIfTrue : expressionIfFalse</code></p>

<pre><code class="language-java">int a = 10;
int b = 20;
int max = (a &gt; b) ? a : b; // 如果a &gt; b为true，max = a；否则 max = b。
System.out.println("最大值是: " + max); // 输出：最大值是: 20
</code></pre>

<h2>5. 控制结构 (Control Structures)</h2>

<p>控制结构用于控制程序的执行流程。</p>

<h3>5.1 条件语句 (Conditional Statements)</h3>

<h4>5.1.1 <code>if</code> 语句</h4>

<p>根据条件是否为真来执行代码块。</p>

<p><strong>语法：</strong></p>

<pre><code class="language-java">if (condition) {
    // 如果条件为 true，执行这里的代码
}
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">int score = 85;
if (score &gt;= 60) {
    System.out.println("及格了！");
}
</code></pre>

<h4>5.1.2 <code>if-else</code> 语句</h4>

<p>如果条件为真，执行 <code>if</code> 块；否则执行 <code>else</code> 块。</p>

<p><strong>语法：</strong></p>

<pre><code class="language-java">if (condition) {
    // 如果条件为 true，执行这里的代码
} else {
    // 如果条件为 false，执行这里的代码
}
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">int age = 16;
if (age &gt;= 18) {
    System.out.println("已成年。");
} else {
    System.out.println("未成年。");
}
</code></pre>

<h4>5.1.3 <code>if-else if-else</code> 语句</h4>

<p>用于检查多个条件。</p>

<p><strong>语法：</strong></p>

<pre><code class="language-java">if (condition1) {
    // 如果 condition1 为 true，执行这里的代码
} else if (condition2) {
    // 如果 condition1 为 false 且 condition2 为 true，执行这里的代码
} else if (condition3) {
    // ... 可以有更多的 else if 块
} else {
    // 如果以上所有条件都为 false，执行这里的代码 (else块可选)
}
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">int score = 75;
if (score &gt;= 90) {
    System.out.println("优秀");
} else if (score &gt;= 80) {
    System.out.println("良好");
} else if (score &gt;= 70) {
    System.out.println("中等");
} else if (score &gt;= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}
</code></pre>

<h4>5.1.4 嵌套 <code>if</code> 语句</h4>

<p><code>if</code> 语句内部可以包含另一个 <code>if</code> 语句。</p>

<pre><code class="language-java">int age = 20;
boolean hasTicket = true;

if (age &gt;= 18) {
    System.out.println("年龄符合要求。");
    if (hasTicket) {
        System.out.println("有票，可以入场。");
    } else {
        System.out.println("没有票，不能入场。");
    }
} else {
    System.out.println("年龄不符合要求，不能入场。");
}
</code></pre>

<h3>5.2 <code>switch</code> 语句</h3>

<p><code>switch</code> 语句用于基于变量的不同值执行不同的代码块。它通常用于替代多个 <code>if-else if</code> 结构，当判断条件是等值比较时。</p>

<p><strong>语法：</strong></p>

<pre><code class="language-java">switch (expression) {
    case value1:
        // expression 的值等于 value1 时执行的代码
        break; // 可选，用于跳出 switch 语句
    case value2:
        // expression 的值等于 value2 时执行的代码
        break;
    // ... 可以有更多的 case
    default:
        // 如果 expression 的值与所有 case 都不匹配，执行这里的代码 (可选)
}
</code></pre>

<p><strong><code>switch</code> 表达式支持的类型：</strong></p>

<ul>
<li><code>byte</code>, <code>short</code>, <code>char</code>, <code>int</code></li>
<li>它们的包装类: <code>Byte</code>, <code>Short</code>, <code>Character</code>, <code>Integer</code></li>
<li><code>String</code> (从 Java 7 开始)</li>
<li>枚举 (Enum)</li>
</ul>

<p><strong><code>break</code> 关键字：</strong></p>

<ul>
<li>每个 <code>case</code> 块通常以 <code>break;</code> 结尾。如果没有 <code>break</code>，程序会继续执行下一个 <code>case</code> 块的代码（称为“穿透”现象），直到遇到 <code>break</code> 或 <code>switch</code> 语句结束。</li>
</ul>

<p><strong><code>default</code> 关键字：</strong></p>

<ul>
<li>如果没有任何 <code>case</code> 匹配，则执行 <code>default</code> 块中的代码。<code>default</code> 块是可选的，并且可以放在 <code>switch</code> 语句的任何位置（但通常放在最后）。</li>
</ul>

<p><strong>示例：</strong></p>

<pre><code class="language-java">int dayOfWeek = 3;
String dayName;

switch (dayOfWeek) {
    case 1:
        dayName = "星期一";
        break;
    case 2:
        dayName = "星期二";
        break;
    case 3:
        dayName = "星期三";
        break;
    case 4:
        dayName = "星期四";
        break;
    case 5:
        dayName = "星期五";
        break;
    case 6:
        dayName = "星期六";
        break;
    case 7:
        dayName = "星期日";
        break;
    default:
        dayName = "无效的日期";
        break;
}
System.out.println(dayName); // 输出: 星期三

// String类型的switch示例
String fruit = "apple";
switch (fruit.toLowerCase()) { // 转换为小写以进行不区分大小写的比较
    case "apple":
        System.out.println("是苹果。");
        break;
    case "banana":
        System.out.println("是香蕉。");
        break;
    default:
        System.out.println("其他水果。");
}
</code></pre>

<h3>5.3 循环语句 (Looping Statements)</h3>

<p>循环语句用于重复执行一段代码。</p>

<h4>5.3.1 <code>for</code> 循环</h4>

<p>当您知道循环需要执行的确切次数时，通常使用 <code>for</code> 循环。</p>

<p><strong>语法：</strong></p>

<pre><code class="language-java">for (initialization; condition; update) {
    // 循环体：如果 condition 为 true，执行这里的代码
}
</code></pre>

<ul>
<li><strong>initialization</strong>：循环开始前执行一次，通常用于初始化循环控制变量。</li>
<li><strong>condition</strong>：每次循环开始前检查。如果为 <code>true</code>，执行循环体；如果为 <code>false</code>，循环终止。</li>
<li><strong>update</strong>：每次循环体执行完毕后执行，通常用于更新循环控制变量。</li>
</ul>

<p><strong>示例：打印数字 0 到 4</strong></p>

<pre><code class="language-java">for (int i = 0; i &lt; 5; i++) {
    System.out.println("i 的值是: " + i);
}
/*
输出:
i 的值是: 0
i 的值是: 1
i 的值是: 2
i 的值是: 3
i 的值是: 4
*/
</code></pre>

<p><strong>示例：计算 1 到 100 的和</strong></p>

<pre><code class="language-java">int sum = 0;
for (int i = 1; i &lt;= 100; i++) {
    sum += i; // sum = sum + i;
}
System.out.println("1到100的和是: " + sum); // 输出: 5050
</code></pre>

<h4>5.3.2 <code>while</code> 循环</h4>

<p>当循环的执行次数不确定，但循环继续的条件已知时，通常使用 <code>while</code> 循环。循环体可能一次都不执行。</p>

<p><strong>语法：</strong></p>

<pre><code class="language-java">while (condition) {
    // 循环体：如果 condition 为 true，执行这里的代码
}
</code></pre>

<ul>
<li><strong>condition</strong>：每次循环开始前检查。如果为 <code>true</code>，执行循环体；如果为 <code>false</code>，循环终止。</li>
</ul>

<p><strong>示例：打印数字 0 到 4</strong></p>

<pre><code class="language-java">int i = 0;
while (i &lt; 5) {
    System.out.println("i 的值是: " + i);
    i++;
}
</code></pre>

<p><strong>示例：用户输入直到输入0为止</strong></p>

<pre><code class="language-java">import java.util.Scanner;

public class WhileDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int number;

        System.out.println("请输入一个数字 (输入0退出):");
        number = scanner.nextInt();

        while (number != 0) {
            System.out.println("你输入了: " + number);
            System.out.println("请继续输入一个数字 (输入0退出):");
            number = scanner.nextInt();
        }
        System.out.println("程序结束。");
        scanner.close();
    }
}
</code></pre>

<h4>5.3.3 <code>do-while</code> 循环</h4>

<p>与 <code>while</code> 循环类似，但 <code>do-while</code> 循环的循环体至少会执行一次，因为条件判断在循环体执行之后。</p>

<p><strong>语法：</strong></p>

<pre><code class="language-java">do {
    // 循环体：先执行一次，然后检查 condition
} while (condition);
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">import java.util.Scanner;

public class DoWhileDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int choice;

        do {
            System.out.println("\n--- 菜单 ---");
            System.out.println("1. 开始游戏");
            System.out.println("2. 查看帮助");
            System.out.println("3. 退出");
            System.out.print("请输入您的选择: ");
            choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    System.out.println("游戏开始...");
                    break;
                case 2:
                    System.out.println("这是帮助信息...");
                    break;
                case 3:
                    System.out.println("感谢使用，再见！");
                    break;
                default:
                    System.out.println("无效的选择，请重新输入。");
            }
        } while (choice != 3);

        scanner.close();
    }
}
</code></pre>

<h4>5.3.4 <code>break</code> 和 <code>continue</code> 语句</h4>

<ul>
<li><strong><code>break</code></strong>：用于立即终止当前所在的循环（<code>for</code>, <code>while</code>, <code>do-while</code>）或 <code>switch</code> 语句。</li>
<li><strong><code>continue</code></strong>：用于跳过当前循环中剩余的语句，并开始下一次迭代。</li>
</ul>

<p><strong><code>break</code> 示例：</strong></p>

<pre><code class="language-java">for (int i = 0; i &lt; 10; i++) {
    if (i == 5) {
        break; // 当 i 等于 5 时，跳出循环
    }
    System.out.println("i = " + i);
}
// 输出: i = 0, i = 1, i = 2, i = 3, i = 4
</code></pre>

<p><strong><code>continue</code> 示例：</strong></p>

<pre><code class="language-java">for (int i = 0; i &lt; 10; i++) {
    if (i % 2 == 0) { // 如果 i 是偶数
        continue; // 跳过本次循环中剩余的语句，直接开始下一次迭代
    }
    System.out.println("奇数: " + i);
}
// 输出: 奇数: 1, 奇数: 3, 奇数: 5, 奇数: 7, 奇数: 9
</code></pre>

<h2>6. 数组 (Arrays)</h2>

<p>数组是用于存储固定大小的同类型元素的集合。</p>

<h3>6.1 声明数组</h3>

<pre><code class="language-java">dataType[] arrayName;  // 推荐方式
// 或
dataType arrayName[];  // C/C++ 风格，不推荐
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">int[] numbers;
String[] names;
double[] scores;
</code></pre>

<h3>6.2 创建数组 (初始化)</h3>

<p>声明数组只是创建了一个引用，并没有实际分配内存空间。需要使用 <code>new</code> 关键字来创建数组并指定其大小。</p>

<h4>6.2.1 动态初始化</h4>

<p>指定数组长度，元素会被赋予默认值（数值型为0，布尔型为false，引用类型为null）。</p>

<pre><code class="language-java">arrayName = new dataType[size];
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">int[] numbers = new int[5]; // 创建一个包含5个整数的数组，所有元素默认为0
// numbers[0] = 0, numbers[1] = 0, ..., numbers[4] = 0

String[] names = new String[3]; // 创建一个包含3个字符串的数组，所有元素默认为null
// names[0] = null, names[1] = null, names[2] = null
</code></pre>

<h4>6.2.2 静态初始化</h4>

<p>在创建数组的同时指定初始值，数组长度由初始值的个数决定。</p>

<pre><code class="language-java">dataType[] arrayName = {value1, value2, ..., valueN};
// 或者
dataType[] arrayName = new dataType[]{value1, value2, ..., valueN};
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">int[] ages = {25, 30, 22, 40}; // 创建并初始化一个包含4个整数的数组
String[] fruits = new String[]{"Apple", "Banana", "Orange"};
</code></pre>

<h3>6.3 访问数组元素</h3>

<p>通过索引（下标）访问数组元素。数组索引从 <code>0</code> 开始，到 <code>length - 1</code> 结束。</p>

<pre><code class="language-java">arrayName[index]
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">int[] scores = new int[3];
scores[0] = 90; // 给第一个元素赋值
scores[1] = 85;
scores[2] = 95;

System.out.println("第一个分数: " + scores[0]); // 输出: 90
System.out.println("第二个分数: " + scores[1]);

// 修改元素值
scores[1] = 88;
System.out.println("修改后的第二个分数: " + scores[1]); // 输出: 88
</code></pre>

<h3>6.4 数组长度</h3>

<p>使用数组的 <code>length</code> 属性获取数组的长度（元素的个数）。</p>

<pre><code class="language-java">int[] data = {10, 20, 30, 40, 50};
System.out.println("数组的长度是: " + data.length); // 输出: 5
</code></pre>

<h3>6.5 遍历数组</h3>

<h4>6.5.1 使用 <code>for</code> 循环</h4>

<pre><code class="language-java">String[] colors = {"Red", "Green", "Blue"};
for (int i = 0; i &lt; colors.length; i++) {
    System.out.println(colors[i]);
}
/*
输出:
Red
Green
Blue
*/
</code></pre>

<h4>6.5.2 使用增强 <code>for</code> 循环 (For-Each Loop)</h4>

<p>更简洁的遍历方式，用于依次访问数组中的每个元素，但不能获取当前元素的索引。</p>

<p><strong>语法：</strong></p>

<pre><code class="language-java">for (dataType element : arrayName) {
    // 处理 element
}
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">String[] colors = {"Red", "Green", "Blue"};
for (String color : colors) {
    System.out.println(color);
}
</code></pre>

<h3>6.6 数组常见问题</h3>

<ul>
<li><p><strong>数组索引越界异常 (ArrayIndexOutOfBoundsException)</strong>：当访问的索引超出了 <code>0</code> 到 <code>length - 1</code> 的范围时发生。</p>
<pre><code class="language-java">int[] arr = new int[3];
// arr[3] = 10; // 这行会抛出 ArrayIndexOutOfBoundsException，因为最大索引是2
</code></pre>
</li>
<li><p><strong>空指针异常 (NullPointerException)</strong>：如果数组引用为 <code>null</code>（即数组未被初始化），尝试访问其元素或 <code>length</code> 属性时会发生。</p>
<pre><code class="language-java">int[] arr = null;
// System.out.println(arr.length); // 这行会抛出 NullPointerException
</code></pre>
</li>
</ul>

<h3>6.7 多维数组</h3>

<p>Java支持多维数组，最常见的是二维数组（可以看作是数组的数组，或表格）。</p>

<h4>6.7.1 声明和创建二维数组</h4>

<pre><code class="language-java">dataType[][] arrayName;

// 动态初始化 (指定行数和列数)
arrayName = new dataType[rows][columns];

// 静态初始化
dataType[][] arrayName = {
    {val11, val12, ...},
    {val21, val22, ...},
    ...
};
</code></pre>

<p><strong>示例：</strong></p>

<pre><code class="language-java">// 动态初始化一个3行4列的二维整数数组
int[][] matrix = new int[3][4];
matrix[0][0] = 1;
matrix[1][2] = 5;

// 静态初始化
String[][] ticTacToe = {
    {"X", "O", "X"},
    {"O", "X", "O"},
    {"X", "O", "X"}
};
</code></pre>

<h4>6.7.2 访问二维数组元素</h4>

<pre><code class="language-java">arrayName[rowIndex][columnIndex]
</code></pre>

<h4>6.7.3 遍历二维数组</h4>

<p>通常使用嵌套循环。</p>

<pre><code class="language-java">int[][] numbers = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

System.out.println("二维数组的行数: " + numbers.length); // 输出: 3
System.out.println("二维数组第一行的列数: " + numbers[0].length); // 输出: 3

for (int i = 0; i &lt; numbers.length; i++) { // 遍历行
    for (int j = 0; j &lt; numbers[i].length; j++) { // 遍历当前行的列
        System.out.print(numbers[i][j] + "\t"); // \t 是制表符
    }
    System.out.println(); // 每行结束后换行
}
/*
输出:
1   2   3
4   5   6
7   8   9
*/

// 使用增强for循环遍历二维数组
for (int[] row : numbers) {
    for (int element : row) {
        System.out.print(element + "\t");
    }
    System.out.println();
}
</code></pre>

<h2>7. 字符串 (Strings)</h2>

<p>在Java中，字符串是 <code>String</code> 类的对象，用于表示一系列字符。<code>String</code> 对象是不可变的（immutable），意味着一旦创建，其内容就不能被修改。</p>

<h3>7.1 创建字符串</h3>

<pre><code class="language-java">// 1. 使用字符串字面量 (最常用)
String str1 = "Hello, Java!";

// 2. 使用 new 关键字和 String 构造函数
String str2 = new String("Welcome");
char[] charArray = {'J', 'a', 'v', 'a'};
String str3 = new String(charArray);
</code></pre>

<h3>7.2 字符串的不可变性</h3>

<p>当对字符串进行修改操作（如连接、替换等）时，实际上是创建了一个新的 <code>String</code> 对象，原始字符串对象保持不变。</p>

<pre><code class="language-java">String s1 = "Hello";
String s2 = s1; // s2 指向与 s1 相同的 "Hello" 对象
s1 = s1 + " World"; // s1 现在指向一个新的 "Hello World" 对象
                  // s2 仍然指向原来的 "Hello" 对象

System.out.println(s1); // 输出: Hello World
System.out.println(s2); // 输出: Hello
</code></pre>

<h3>7.3 常用 <code>String</code> 方法</h3>

<p><code>String</code> 类提供了许多有用的方法来操作字符串。</p>

<table>
<thead>
<tr>
<th>方法签名</th>
<th>描述</th>
<th>示例 (<code>String text = "Hello World";</code>)</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>int length()</code></td>
<td>返回字符串的长度 (字符数)</td>
<td><code>text.length()</code> (结果: 11)</td>
</tr>
<tr>
<td><code>char charAt(int index)</code></td>
<td>返回指定索引处的字符</td>
<td><code>text.charAt(0)</code> (结果: 'H')</td>
</tr>
<tr>
<td><code>String concat(String str)</code></td>
<td>将指定字符串连接到此字符串的末尾 (返回新字符串)</td>
<td><code>text.concat("!")</code> (结果: "Hello World!")</td>
</tr>
<tr>
<td><code>boolean equals(Object obj)</code></td>
<td>将此字符串与指定对象进行比较 (比较内容)</td>
<td><code>text.equals("Hello World")</code> (结果: true)</td>
</tr>
<tr>
<td><code>boolean equalsIgnoreCase(String anotherString)</code></td>
<td>忽略大小写比较两个字符串</td>
<td><code>text.equalsIgnoreCase("hello world")</code> (结果: true)</td>
</tr>
<tr>
<td><code>int indexOf(String str)</code></td>
<td>返回指定子字符串在此字符串中第一次出现的索引，如果未找到则返回 -1</td>
<td><code>text.indexOf("World")</code> (结果: 6)</td>
</tr>
<tr>
<td><code>int indexOf(String str, int fromIndex)</code></td>
<td>从指定索引开始搜索子字符串</td>
<td><code>text.indexOf("o", 5)</code> (结果: 7)</td>
</tr>
<tr>
<td><code>int lastIndexOf(String str)</code></td>
<td>返回指定子字符串在此字符串中最后一次出现的索引</td>
<td><code>text.lastIndexOf("o")</code> (结果: 7)</td>
</tr>
<tr>
<td><code>String substring(int beginIndex)</code></td>
<td>返回一个新字符串，它是此字符串从 <code>beginIndex</code> 到末尾的子字符串</td>
<td><code>text.substring(6)</code> (结果: "World")</td>
</tr>
<tr>
<td><code>String substring(int beginIndex, int endIndex)</code></td>
<td>返回一个新字符串，它是此字符串从 <code>beginIndex</code> 到 <code>endIndex-1</code> 的子字符串</td>
<td><code>text.substring(0, 5)</code> (结果: "Hello")</td>
</tr>
<tr>
<td><code>String toLowerCase()</code></td>
<td>将此字符串中的所有字符都转换为小写 (返回新字符串)</td>
<td><code>text.toLowerCase()</code> (结果: "hello world")</td>
</tr>
<tr>
<td><code>String toUpperCase()</code></td>
<td>将此字符串中的所有字符都转换为大写 (返回新字符串)</td>
<td><code>text.toUpperCase()</code> (结果: "HELLO WORLD")</td>
</tr>
<tr>
<td><code>String trim()</code></td>
<td>返回一个新字符串，它是此字符串去掉两端空白字符后的副本</td>
<td><code>"  Hi  ".trim()</code> (结果: "Hi")</td>
</tr>
<tr>
<td><code>String replace(char oldChar, char newChar)</code></td>
<td>返回一个新字符串，用 <code>newChar</code> 替换此字符串中所有的 <code>oldChar</code></td>
<td><code>text.replace('o', 'a')</code> (结果: "Hella Warld")</td>
</tr>
<tr>
<td><code>String replace(CharSequence target, CharSequence replacement)</code></td>
<td>用 <code>replacement</code> 替换所有匹配 <code>target</code> 的子串</td>
<td><code>text.replace("World", "Java")</code> (结果: "Hello Java")</td>
</tr>
<tr>
<td><code>boolean startsWith(String prefix)</code></td>
<td>测试此字符串是否以指定的前缀开始</td>
<td><code>text.startsWith("He")</code> (结果: true)</td>
</tr>
<tr>
<td><code>boolean endsWith(String suffix)</code></td>
<td>测试此字符串是否以指定的后缀结束</td>
<td><code>text.endsWith("ld")</code> (结果: true)</td>
</tr>
<tr>
<td><code>boolean contains(CharSequence s)</code></td>
<td>当且仅当此字符串包含指定的 char 值序列时，返回 true</td>
<td><code>text.contains("orl")</code> (结果: true)</td>
</tr>
<tr>
<td><code>String[] split(String regex)</code></td>
<td>根据匹配给定的正则表达式来拆分此字符串 (返回字符串数组)</td>
<td><code>"a,b,c".split(",")</code> (结果: <code>["a", "b", "c"]</code>)</td>
</tr>
<tr>
<td><code>static String join(CharSequence delimiter, CharSequence... elements)</code></td>
<td>使用指定的分隔符连接多个字符串 (Java 8+)</td>
<td><code>String.join("-", "Java", "is", "fun")</code> (结果: "Java-is-fun")</td>
</tr>
<tr>
<td><code>boolean isEmpty()</code></td>
<td>当且仅当 <code>length()</code> 为 0 时返回 <code>true</code></td>
<td><code>"".isEmpty()</code> (结果: true)</td>
</tr>
</tbody>
</table>

<p><strong>示例：</strong></p>

<pre><code class="language-java">public class StringMethodsDemo {
    public static void main(String[] args) {
        String greeting = "   Hello, World! Welcome to Java.   ";

        System.out.println("原始字符串: '" + greeting + "'");
        System.out.println("长度: " + greeting.length());
        System.out.println("去除两端空格: '" + greeting.trim() + "'");
        System.out.println("转换为大写: " + greeting.toUpperCase());
        System.out.println("转换为小写: " + greeting.toLowerCase());

        String trimmedGreeting = greeting.trim();
        System.out.println("子字符串 (从索引7开始): " + trimmedGreeting.substring(7)); // "World! Welcome to Java."
        System.out.println("子字符串 (索引7到12): " + trimmedGreeting.substring(7, 12)); // "World"

        System.out.println("是否包含 'Welcome': " + trimmedGreeting.contains("Welcome")); // true
        System.out.println("替换 'Java' 为 'Programming': " + trimmedGreeting.replace("Java", "Programming"));

        String data = "apple,banana,orange";
        String[] fruits = data.split(",");
        System.out.print("水果: ");
        for (String fruit : fruits) {
            System.out.print(fruit + " "); // apple banana orange
        }
        System.out.println();

        String joinedString = String.join(" - ", "One", "Two", "Three");
        System.out.println("连接后的字符串: " + joinedString); // One - Two - Three
    }
}
</code></pre>

<h3>7.4 字符串比较</h3>

<ul>
<li>使用 <code>==</code> 比较字符串：比较的是两个字符串对象的内存地址是否相同。</li>
<li>使用 <code>equals()</code> 方法比较字符串：比较的是两个字符串的内容是否相同。</li>
</ul>

<p><strong>对于字符串内容的比较，应始终使用 <code>equals()</code> 方法。</strong></p>

<pre><code class="language-java">String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = new String("hello");

System.out.println("s1 == s2: " + (s1 == s2));         // true (因为s1和s2指向字符串常量池中的同一个对象)
System.out.println("s1 == s3: " + (s1 == s3));         // false (s3是通过new创建的，在堆内存中有新的地址)
System.out.println("s3 == s4: " + (s3 == s4));         // false (s3和s4是两个不同的对象，即使内容相同)

System.out.println("s1.equals(s2): " + s1.equals(s2)); // true
System.out.println("s1.equals(s3): " + s1.equals(s3)); // true
System.out.println("s3.equals(s4): " + s3.equals(s4)); // true
</code></pre>

<h3>7.5 <code>StringBuilder</code> 和 <code>StringBuffer</code></h3>

<p>由于 <code>String</code> 对象是不可变的，当需要频繁修改字符串内容时（例如在循环中拼接字符串），使用 <code>String</code> 会产生大量临时的字符串对象，效率较低。</p>
<p>为了解决这个问题，Java 提供了 <code>StringBuilder</code> 和 <code>StringBuffer</code> 类，它们表示可变的字符序列。</p>

<ul>
<li><strong><code>StringBuilder</code></strong>：线程不安全，但效率较高。推荐在单线程环境下使用。</li>
<li><strong><code>StringBuffer</code></strong>：线程安全，但效率较低。适用于多线程环境。</li>
</ul>

<p>它们提供了类似的方法，如 <code>append()</code> (追加), <code>insert()</code> (插入), <code>delete()</code> (删除), <code>replace()</code> (替换), <code>reverse()</code> (反转) 等。</p>

<p><strong>示例 (<code>StringBuilder</code>)：</strong></p>

<pre><code class="language-java">public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();

        sb.append("Hello");
        sb.append(" ");
        sb.append("World");
        sb.append("!");

        System.out.println(sb.toString()); // 输出: Hello World!

        sb.insert(6, "Java "); // 在索引6处插入 "Java "
        System.out.println(sb.toString()); // 输出: Hello Java World!

        sb.replace(6, 11, "Beautiful "); // 替换索引6到10的内容
        System.out.println(sb.toString()); // 输出: Hello Beautiful World!

        sb.delete(0, 6); // 删除索引0到5的内容
        System.out.println(sb.toString()); // 输出: Beautiful World!

        sb.reverse();
        System.out.println(sb.toString()); // 输出: !dlroW lufituaeB
    }
}
</code></pre>

<h2>8. 综合练习</h2>

<h3>练习1：简单计算器</h3>

<p>编写一个程序，提示用户输入两个数字和一个运算符（+、-、*、/），然后计算并显示结果。</p>

<pre><code class="language-java">import java.util.Scanner;

public class SimpleCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入第一个数字: ");
        double num1 = scanner.nextDouble();

        System.out.print("请输入运算符 (+, -, *, /): ");
        char operator = scanner.next().charAt(0);

        System.out.print("请输入第二个数字: ");
        double num2 = scanner.nextDouble();

        double result = 0;
        boolean validOperation = true;

        switch (operator) {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num1 - num2;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                if (num2 != 0) {
                    result = num1 / num2;
                } else {
                    System.out.println("错误：除数不能为零！");
                    validOperation = false;
                }
                break;
            default:
                System.out.println("错误：无效的运算符！");
                validOperation = false;
        }

        if (validOperation) {
            System.out.println("结果: " + num1 + " " + operator + " " + num2 + " = " + result);
        }

        scanner.close();
    }
}
</code></pre>

<h3>练习2：数组元素查找</h3>

<p>创建一个整数数组，并提示用户输入一个数字。程序应判断该数字是否存在于数组中，并输出相应信息。</p>

<pre><code class="language-java">import java.util.Scanner;

public class ArraySearch {
    public static void main(String[] args) {
        int[] numbers = {10, 25, 5, 42, 18, 30, 7};
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入要查找的数字: ");
        int target = scanner.nextInt();

        boolean found = false;
        int foundIndex = -1;

        for (int i = 0; i &lt; numbers.length; i++) {
            if (numbers[i] == target) {
                found = true;
                foundIndex = i;
                break; // 找到后即可退出循环
            }
        }

        if (found) {
            System.out.println("数字 " + target + " 在数组中找到了，索引为: " + foundIndex);
        } else {
            System.out.println("数字 " + target + " 在数组中未找到。");
        }

        scanner.close();
    }
}
</code></pre>

<h3>练习3：字符串反转</h3>

<p>提示用户输入一个字符串，然后程序将该字符串反转并输出。</p>

<p><strong>方法一：使用 <code>StringBuilder</code></strong></p>

<pre><code class="language-java">import java.util.Scanner;

public class StringReverseBuilder {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个字符串: ");
        String original = scanner.nextLine();

        StringBuilder sb = new StringBuilder(original);
        String reversed = sb.reverse().toString();

        System.out.println("反转后的字符串: " + reversed);
        scanner.close();
    }
}
</code></pre>

<p><strong>方法二：使用 <code>for</code> 循环和 <code>charAt()</code></strong></p>

<pre><code class="language-java">import java.util.Scanner;

public class StringReverseLoop {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个字符串: ");
        String original = scanner.nextLine();
        String reversed = "";

        for (int i = original.length() - 1; i &gt;= 0; i--) {
            reversed = reversed + original.charAt(i);
        }

        System.out.println("反转后的字符串: " + reversed);
        scanner.close();
    }
}
</code></pre>
    </div>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/prism.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/components/prism-java.min.js"></script>
</body>
</html>